8.04. Разработка на Unity

ДЛЯ НОВИЧКОВНЕ ДЛЯ НОВИЧКОВНЕ ОБЯЗАТЕЛЬНОВ РАЗРАБОТКЕ

Всем

Введение

Unity — это мощный кроссплатформенный игровой движок, используемый для создания 2D и 3D приложений, игр и интерактивного контента. Его гибкая архитектура и интуитивно понятный редактор позволяют эффективно управлять проектом, от первоначального прототипа до финальной сборки. Данная глава охватывает ключевые аспекты работы с Unity, включая навигацию по интерфейсу, создание и настройку игровых объектов, использование компонентов и систему префабов.

Установка и настройка окружения

Для начала разработки необходимо установить два основных компонента: Unity Hub и Visual Studio Community.

Установка Visual Studio Community:
- Перейдите на официальный сайт Visual Studio (https://visualstudio.microsoft.com/ru/vs/community/) и скачайте бесплатную версию Community.
- Запустите установщик и выберите рабочие нагрузки: "Разработка игр с использованием Unity" и "Разработка классических приложений .NET". Это обеспечит наличие необходимых инструментов и шаблонов.
Установка Unity Hub и редактора:
- Скачайте Unity Hub с официального сайта Unity (https://unity.com/ru/download).
- Установите и запустите Unity Hub. Авторизуйтесь или создайте учетную запись.
- В разделе "Installs" добавьте новую версию Unity. Рекомендуется использовать LTS-версию (например, 2022 LTS) для максимальной стабильности.
- Во время установки Unity выберите Visual Studio Community в качестве среды разработки по умолчанию.
Создание проекта:
- В Unity Hub перейдите во вкладку "Projects" и нажмите "New Project".
- Выберите подходящий шаблон (например, "3D").
- Укажите имя проекта и его расположение на диске.
- Нажмите "Create". Проект будет создан, и Unity Editor автоматически откроется.

Основные окна редактора Unity

Интерфейс Unity состоит из нескольких основных панелей, каждая из которых выполняет свою функцию.

Scene View (Вид сцены):
- Представляет собой основное пространство для визуального редактирования сцены.
- Позволяет перемещать, вращать и масштабировать игровые объекты с помощью мыши и клавиш (W - перемещение, E - вращение, R - масштабирование).
- Инструменты в верхнем левом углу позволяют изменять режим просмотра (перспективный/ортогональный) и способ манипуляции объектами (перемещение по осям, вращение вокруг осей, масштабирование).
Game View (Вид игры):
- Отображает сцену так, как она будет выглядеть при запуске игры.
- Позволяет изменять разрешение экрана и соотношение сторон для тестирования адаптации интерфейса под разные устройства.
Hierarchy (Иерархия):
- Содержит список всех игровых объектов, находящихся на текущей сцене.
- Объекты могут быть организованы в виде дерева, где один объект является дочерним по отношению к другому (родитель-потомок). Дочерние объекты наследуют трансформации (позицию, вращение, масштаб) своего родителя.
Project Window (Окно проекта):
- Является файловым менеджером для всех ресурсов вашего проекта: скрипты, модели, текстуры, звуки, префабы и т.д.
- Позволяет организовывать ресурсы в папки (например, Scripts, Models, Textures, Prefabs) для удобства управления.
- Предоставляет доступ к настройкам импорта ресурсов и возможность создавать новые элементы (скрипты, материалы, префабы).
Inspector (Инспектор):
- Отображает все компоненты и их свойства для выбранного объекта в Hierarchy или Scene View.
- Это центральное место для настройки поведения объектов. Здесь можно изменять параметры компонентов, назначать ссылки на другие объекты и загружать ресурсы (например, модель или текстуру).
- Все изменения, внесенные в Inspector, сохраняются вместе с объектом.
Console (Консоль):
- Отображает сообщения, генерируемые во время выполнения сцен (логи), а также предупреждения и ошибки.
- Критически важна для отладки кода. Ошибки в скриптах будут выделены красным цветом, и щелчок по сообщению позволяет перейти к соответствующей строке в коде.

Игровые объекты и компоненты

Основой любой сцены в Unity являются игровые объекты (GameObject). Сам по себе GameObject — это пустой контейнер, который становится функциональным только после добавления к нему компонентов.

Создание объектов:
- Через контекстное меню в Hierarchy: клик правой кнопкой мыши -> Create Empty (пустой объект) или выбрать тип объекта из раздела 3D Object (Cube, Sphere, etc.).
- Через главное меню: GameObject -> Create Empty / 3D Object.
- Через кнопку "+" в верхней части панели Hierarchy.
Основные компоненты:
- Transform: Присутствует у каждого GameObject. Определяет позицию, вращение и масштаб объекта в мировом пространстве.
- Mesh Renderer: Отвечает за визуализацию объекта. Получает геометрию из компонента Mesh Filter и применяет к ней материал.
- Mesh Filter: Хранит сетку (mesh) объекта, которая определяет его форму.
- Collider: Определяет физическую границу объекта для системы обнаружения столкновений (например, Box Collider, Sphere Collider).
- Rigidbody: Придает объекту физические свойства (массу, инерцию) и позволяет ему взаимодействовать с системой физики Unity. Объекты с Rigidbody подвержены действию силы тяжести и могут сталкиваться с другими объектами, имеющими Collider.
Настройка свойств через Inspector:
- Для изменения поведения объекта необходимо настроить параметры его компонентов в Inspector.
- Например, чтобы объект падал, добавьте к нему компонент Rigidbody. Чтобы он мог сталкиваться с другими объектами, убедитесь, что у него и у других объектов есть компоненты Collider.

Префабы: повторное использование объектов

Префаб (Prefab) — это шаблон игрового объекта, который может быть многократно использован в сцене. Это ключевой инструмент для обеспечения согласованности и эффективности разработки.

Создание префаба:
1. Создайте и настройте игровой объект в сцене (например, настройте его компоненты, назначьте текстуры).
2. Перетащите этот объект из панели Hierarchy в папку Prefabs в окне Project.
3. Объект в сцене станет экземпляром префаба (его название в Hierarchy будет синим).
Преимущества использования префабов:
- Упрощение управления: Все экземпляры одного префаба имеют одинаковую базовую конфигурацию.
- Легкость в тестировании и обновлении: Если вы внесете изменения в сам префаб (в папке Project), все его экземпляры на всех сценах автоматически получат эти изменения. Это позволяет быстро вносить глобальные изменения (например, изменить здоровье врага).
- Гибкость: Экземпляры префаба можно модифицировать (например, изменить позицию или цвет материала), и при необходимости применить эти изменения обратно к оригинальному префабу с помощью кнопки "Apply All" в разделе Overrides в Inspector.

Работа со скриптами

Скрипты на C# определяют логику и поведение игровых объектов.

Создание скрипта:
- В окне Project кликните правой кнопкой мыши -> Create -> C# Script.
- Назовите скрипт (например, PlayerController) и дважды щелкните по нему, чтобы открыть в Visual Studio.
Прикрепление скрипта к объекту:
- Перетащите файл скрипта из окна Project на объект в Hierarchy.
- Альтернативно, выберите объект, затем в Inspector нажмите Add Component и введите имя скрипта.
- После этого скрипт появится в списке компонентов объекта в Inspector.
Передача ссылок между объектами (через Inspector):
- Чтобы скрипт мог взаимодействовать с другими объектами, необходимо объявить переменные с модификатором доступа public.
```
public class PlayerController : MonoBehaviour
{
    // Эта переменная будет отображаться в Inspector
    public GameObject applePrefab;
    public float speed = 5f;

    void Update()
    {
        // Использование переменных
        if (Input.GetKeyDown(KeyCode.Space))
        {
            Instantiate(applePrefab, transform.position, Quaternion.identity);
        }
    }
}
```
- После сохранения скрипта и возвращения в Unity, поля applePrefab и speed станут видимыми в Inspector компонента PlayerController.
- Перетащите нужный объект (например, префаб яблока) из Hierarchy или Project в поле applePrefab в Inspector. Это создаст прямую ссылку, которую скрипт сможет использовать во время выполнения.

Работа с UI (User Interface)

Интерфейс пользователя — критически важный элемент любого приложения. В Unity для создания UI используется система Canvas, которая служит контейнером для всех элементов интерфейса, таких как кнопки, текст, полосы здоровья и т.д.

Создание Canvas:
- Создайте новый объект: GameObject -> UI -> Canvas.
- Canvas может работать в трех режимах рендеринга:
  1. Screen Space - Overlay: UI отображается поверх игры. Масштабируется автоматически под разрешение экрана.
  2. Screen Space - Camera: UI привязан к конкретной камере, что позволяет контролировать его глубину.
  3. World Space: UI является частью 3D-сцены и может быть помещен где угодно в игровом мире.
- Для большинства случаев рекомендуется использовать Screen Space - Overlay.
Основные элементы UI:
- Text / TextMeshPro: Отображает текст. TextMeshPro (TMP) — это продвинутая альтернатива стандартному Text, предлагающая лучшее качество шрифтов, эффекты (тенями, контурами) и гибкие настройки.
- Image: Отображает спрайты или цветные фоны. Используется для создания полос здоровья, иконок, рамок.
- Button: Интерактивная кнопка, реагирующая на клики. Состоит из компонентов Image (для фона) и Button, который обрабатывает события нажатия.
- Slider: Элемент для отображения прогресса (например, здоровье, энергия). Состоит из фона (Background) и заполняемой области (Fill Area).
Настройка слайдера (Health Bar):
1. Создайте слайдер: GameObject -> UI -> Slider.
2. Удалите компонент Handle Slide Area, если не нужна возможность перетаскивания бегунка.
3. В инспекторе найдите раздел Fill Area -> Fill. Настройте цвет и размер заполняемой части.
4. Чтобы управлять значением слайдера из скрипта, получите ссылку на компонент Slider через [SerializeField].

using UnityEngine;
using UnityEngine.UI;

public class PlayerHealth : MonoBehaviour
{
    [SerializeField] private Slider healthBar; // Ссылка на слайдер
    [SerializeField] private float maxHealth = 100f;
    private float currentHealth;

    void Start()
    {
        currentHealth = maxHealth;
        UpdateHealthBar();
    }

    public void TakeDamage(float damage)
    {
        currentHealth = Mathf.Clamp(currentHealth - damage, 0f, maxHealth);
        UpdateHealthBar();

        if (currentHealth <= 0f)
        {
            // Логика поражения
            Debug.Log("Игрок погиб!");
        }
    }

    private void UpdateHealthBar()
    {
        healthBar.value = currentHealth / maxHealth; // Обновляем значение от 0 до 1
    }
}

Анимация и Timeline

Unity предоставляет мощные инструменты для создания анимации как 3D-объектов, так и UI.

Анимация свойств с помощью Animation Window:
1. Выделите объект, который нужно анимировать.
2. Откройте окно Window -> Animation -> Animation.
3. Нажмите Create и укажите имя анимации (например, FadeIn). Файл .anim будет создан в проекте.
4. Запишите ключевые кадры (keyframes), изменяя свойства объекта (позиция, вращение, масштаб, прозрачность материала) во времени.
5. Для анимации прозрачности необходимо использовать материал со шейдером, поддерживающим прозрачность (например, Standard (Transparent)).
Плавное изменение параметров (Lerp):
- Для плавного изменения числовых значений (например, высоты приседа, яркости света) используется линейная интерполяция Mathf.Lerp.
- Ключевой момент — использование Time.deltaTime для независимости от частоты кадров.

using UnityEngine;

public class SmoothMovement : MonoBehaviour
{
    [SerializeField] private float targetHeight = 1f; // Конечная высота
    [SerializeField] private float duration = 1f;     // Время перехода

    private Vector3 startPosition;
    private float elapsedTime = 0f;

    void Start()
    {
        startPosition = transform.position;
    }

    void Update()
    {
        if (elapsedTime < duration)
        {
            elapsedTime += Time.deltaTime;
            float t = elapsedTime / duration; // Прогресс от 0 до 1
            float currentY = Mathf.Lerp(startPosition.y, targetHeight, t);
            transform.position = new Vector3(transform.position.x, currentY, transform.position.z);
        }
    }
}

Физические взаимодействия: Rigidbody и Raycast

Для реализации реалистичных взаимодействий используются компоненты физики.

Rigidbody:
- Компонент Rigidbody добавляет объекту массу, инерцию и позволяет ему подчиняться законам физики (гравитация, столкновения).
- Движение объекта с Rigidbody должно осуществляться через применение сил (AddForce) или изменение скорости (velocity), а не прямое изменение transform.position.
Raycast (луч):
- Raycast — это метод "бросания" невидимого луча из точки в заданном направлении для обнаружения объектов на его пути.
- Широко используется для реализации стрельбы, выбора объектов мышью, проверки контакта с землей.

using UnityEngine;

public class PlayerRaycast : MonoBehaviour
{
    [SerializeField] private Transform cameraTransform;
    [SerializeField] private float rayDistance = 10f;
    [SerializeField] private LayerMask interactableLayers;

    void Update()
    {
        if (Input.GetMouseButtonDown(0))
        {
            Ray ray = new Ray(cameraTransform.position, cameraTransform.forward);
            RaycastHit hit;

            if (Physics.Raycast(ray, out hit, rayDistance, interactableLayers))
            {
                Debug.Log($"Обнаружен объект: {hit.collider.gameObject.name}");
                // Реализуйте логику взаимодействия (например, поднятие предмета)
            }
        }
    }
}

Управление объектами: реализация механики "поднятия и переноски"

Реализация взаимодействия с объектами, такими как поднятие и переноска, является распространенной задачей в 3D-играх. Она основывается на комбинации Raycast для выбора объекта и физических компонентов (Rigidbody) для управления его движением.

Настройка префаба объекта для переноски:
1. Создайте игровой объект (например, куб).
2. Добавьте ему компонент Rigidbody для участия в физическом симуляторе.
3. Добавьте коллайдер (Box Collider), чтобы система обнаружения столкновений могла его "увидеть".
4. Создайте новый скрипт DraggableObject.cs и прикрепите его к объекту.
5. Назначьте объекту тег, например, DraggableObject, для удобной фильтрации.
Скрипт DraggableObject: управление состоянием объекта:
- Скрипт должен управлять двумя состояниями: "в покое" и "переносится".
- При переноске гравитация отключается, а движение объекта становится плавным за счет интерполяции скорости.

using UnityEngine;

[RequireComponent(typeof(Rigidbody))]
public class DraggableObject : MonoBehaviour
{
    [SerializeField] private float followSpeed = 15f;
    [SerializeField] private float damping = 20f;

    private Rigidbody rb;
    private Vector3 targetPosition;
    private bool isFollowing = false;

    private void Start()
    {
        rb = GetComponent<Rigidbody>();
        // Гравитация включена по умолчанию
    }

    private void FixedUpdate()
    {
        if (!isFollowing) return;

        // Рассчитываем желаемую скорость
        Vector3 directionToTarget = targetPosition - rb.position;
        float distanceToTarget = directionToTarget.magnitude;
        Vector3 desiredVelocity = directionToTarget.normalized * followSpeed * distanceToTarget;

        // Плавно изменяем текущую скорость к желаемой
        rb.velocity = Vector3.Lerp(rb.velocity, desiredVelocity, damping * Time.fixedDeltaTime);
    }

    public void Follow(Vector3 target)
    {
        targetPosition = target;
        isFollowing = true;
        rb.useGravity = false; // Отключаем гравитацию
    }

    public void StopFollow()
    {
        isFollowing = false;
        rb.useGravity = true; // Возвращаем гравитацию
        rb.velocity = Vector3.zero; // Останавливаем движение по инерции
    }
}

Интеграция с системой Raycast:
- Модифицируем скрипт PlayerRaycast, чтобы он мог начинать и прекращать процесс переноски.

public class PlayerRaycast : MonoBehaviour
{
    [SerializeField] private float maxDistance = 5f;
    [SerializeField] private Transform cameraTransform;
    [SerializeField] private LayerMask interactableLayers;
    [SerializeField] private float dragDistance = 2f;

    private DraggableObject currentlyDraggedObject;

    void Update()
    {
        // Если уже что-то несем, обновляем цель
        if (currentlyDraggedObject != null)
        {
            Vector3 newTargetPosition = cameraTransform.position + cameraTransform.forward * dragDistance;
            currentlyDraggedObject.Follow(newTargetPosition);

            // Отпустить объект при повторном нажатии ЛКМ
            if (Input.GetMouseButtonDown(0))
            {
                currentlyDraggedObject.StopFollow();
                currentlyDraggedObject = null;
            }
        }
        else
        {
            // Попытаться подобрать объект при нажатии ЛКМ
            if (Input.GetMouseButtonDown(0))
            {
                TryPickUpObject();
            }
        }
    }

    private void TryPickUpObject()
    {
        Ray ray = new Ray(cameraTransform.position, cameraTransform.forward);
        RaycastHit hit;

        if (Physics.Raycast(ray, out hit, maxDistance, interactableLayers))
        {
            if (hit.collider.CompareTag("DraggableObject"))
            {
                if (hit.collider.TryGetComponent(out DraggableObject draggable))
                {
                    Vector3 initialTargetPosition = cameraTransform.position + cameraTransform.forward * dragDistance;
                    draggable.Follow(initialTargetPosition);
                    currentlyDraggedObject = draggable;
                }
            }
        }
    }
}

Сцены и загрузка уровней

Проект в Unity состоит из одной или нескольких сцен. Каждая сцена представляет собой отдельную часть игры (меню, уровень, экран проигрыша).

Создание и добавление сцен:
1. Создайте новую сцену: File -> New Scene.
2. Сохраните сцену в папке проекта (например, Scenes/MainMenu.unity, Scenes/GameLevel.unity).
3. Для корректной загрузки сцены через API необходимо добавить ее в сборку. Перейдите в File -> Build Settings.
4. Перетащите все используемые сцены из окна Project в список "Scenes in Build". Это один из наиболее частых источников ошибок при запуске игры.
Загрузка сцены программно:
- Используйте пространство имен UnityEngine.SceneManagement.
- Метод SceneManager.LoadScene() позволяет загрузить сцену по имени или индексу.

using UnityEngine;
using UnityEngine.SceneManagement;

public class MenuController : MonoBehaviour
{
    public void LoadGame()
    {
        SceneManager.LoadScene("GameLevel"); // По имени сцены
    }

    public void QuitGame()
    {
        #if UNITY_EDITOR
            UnityEditor.EditorApplication.isPlaying = false;
        #else
            Application.Quit();
        #endif
    }
}

Сохранение данных: PlayerPrefs

Для сохранения небольших объемов данных между сессиями игры (настройки, прогресс, чекпоинты) можно использовать PlayerPrefs.

Основные методы:
- PlayerPrefs.SetFloat(key, value)
- PlayerPrefs.SetInt(key, value)
- PlayerPrefs.SetString(key, value)
- PlayerPrefs.GetFloat(key, defaultValue)
- PlayerPrefs.GetInt(key, defaultValue)
- PlayerPrefs.GetString(key, defaultValue)
Пример: сохранение позиции чекпоинта:

// Скрипт, привязанный к игроку
public class CheckpointManager : MonoBehaviour
{
    private void Start()
    {
        // Загружаем последнюю сохраненную позицию при старте
        transform.position = new Vector3(
            PlayerPrefs.GetFloat("CheckpointX", 0f),
            PlayerPrefs.GetFloat("CheckpointY", 2f),
            PlayerPrefs.GetFloat("CheckpointZ", 0f)
        );
    }

    private void OnTriggerEnter(Collider other)
    {
        if (other.CompareTag("Checkpoint"))
        {
            // Сохраняем текущую позицию игрока
            PlayerPrefs.SetFloat("CheckpointX", transform.position.x);
            PlayerPrefs.SetFloat("CheckpointY", transform.position.y);
            PlayerPrefs.SetFloat("CheckpointZ", transform.position.z);
            PlayerPrefs.Save(); // Явное сохранение (необязательно, но рекомендуется)
        }
    }
}

Virtual Camera

Пакет Cinemachine предоставляет мощный инструмент — Virtual Camera, который упрощает создание динамичных и кинематографичных ракурсов.

Установка Cinemachine:
- Откройте Package Manager (Window -> Package Manager).
- Найдите и установите пакет Cinemachine.
Настройка камеры слежения:
1. Создайте Virtual Camera: GameObject -> Camera -> Cinemachine Virtual Camera.
2. В инспекторе найдите поле Follow и перетащите туда объект игрока. Камера будет следовать за этим объектом.
3. В поле Look At также укажите игрока, чтобы камера всегда была направлена на него.
4. Настройте параметры в разделе Body:
  - Transposer: Задает смещение камеры относительно цели (например, (0, 2, -5) для вида от третьего лица).
  - Damping: Контролирует плавность движения камеры. Высокие значения делают движение более медленным и плавным.

Работа с коллайдерами: триггеры и физические столкновения

Компонент Collider определяет форму границ объекта в пространстве. В зависимости от настройки, он может использоваться для двух различных целей: обнаружения физических столкновений или запуска событий при прохождении одного объекта сквозь другой (триггер).

Физическое столкновение:
- По умолчанию, когда у объекта есть Collider и Rigidbody, он будет физически взаимодействовать с другими объектами, имеющими Collider.
- Это используется для реализации стен, пола, подвижных платформ и т.д.
- События: OnCollisionEnter, OnCollisionStay, OnCollisionExit.
Триггер (Trigger):
- Если в инспекторе компонента Collider установить флажок Is Trigger, объект перестает быть "твердым" и позволяет другим объектам проходить сквозь него.
- Вместо этого, при входе, пребывании и выходе другого объекта из зоны действия коллайдера, вызываются специальные события-триггеры.
- Широко применяется для:
  - Запуска сценариев при входе игрока в область (например, активация чекпоинта).
  - Сбора предметов (игрок проходит через объект-монету).
  - Обнаружения врагов в радиусе атаки.
  - Активации ловушек или сюжетных событий.
- События: OnTriggerEnter, OnTriggerStay, OnTriggerExit.
Реализация сбора предметов (Pickup):

using UnityEngine;

public class Pickup : MonoBehaviour
{
    private void OnTriggerEnter(Collider other)
    {
        // Проверяем, что в триггер попал игрок (по тегу)
        if (other.CompareTag("Player"))
        {
            // Увеличиваем счет игрока (пример)
            PlayerScore.Instance.AddPoints(10);

            // Уничтожаем сам объект-предмет
            Destroy(gameObject);
        }
    }
}

Управление видимостью объектов: SetActive()

Метод SetActive() является основным способом программного управления видимостью и активностью игровых объектов. Это критически важно для таких элементов, как экраны меню, окна проигрыша, диалоговые окна и т.д.

Синтаксис: gameObject.SetActive(bool state);
- true: объект становится активным и видимым.
- false: объект деактивируется, все его компоненты (включая скрипты) перестают работать, и он исчезает с экрана.
Пример: управление экраном проигрыша:

public class GameOverManager : MonoBehaviour
{
    [SerializeField] private GameObject loseScreen; // Ссылка на UI-объект экрана проигрыша

    public void ShowGameOver()
    {
        // Деактивируем игрока (останавливаем его поведение)
        playerController.enabled = false;
        // Показываем экран проигрыша
        loseScreen.SetActive(true);
    }

    public void HideGameOver()
    {
        // Скрываем экран проигрыша
        loseScreen.SetActive(false);
        // Можно добавить логику рестарта игры
    }
}

Оптимизация производительности: Object Pooling

Частое создание (Instantiate) и уничтожение (Destroy) объектов во время игры (например, пуль, частиц, монет) является крайне неэффективной операцией, которая может вызывать "лаги" (hitching). Паттерн Object Pooling решает эту проблему путем повторного использования уже созданных объектов.

Принцип работы:
1. При старте игры создаются несколько экземпляров объекта (например, 10 пуль) и помещаются в "пул" (список), где они находятся в неактивном состоянии.
2. Когда игре нужна пуля, она берется из пула (активируется), а не создается заново.
3. Когда пуля больше не нужна (например, достигла цели или вышла за пределы экрана), вместо удаления она возвращается в пул (деактивируется и помещается обратно в список).
Преимущества:
- Исключение затрат времени на динамическое выделение памяти (Instantiate/Destroy).
- Гладкая работа игры даже при высокой частоте появления объектов.
Базовая реализация пула:

using System.Collections.Generic;
using UnityEngine;

public class ObjectPool : MonoBehaviour
{
    [SerializeField] private GameObject objectPrefab; // Префаб объекта для пула
    [SerializeField] private int poolSize = 10;      // Начальный размер пула

    private Queue<GameObject> pooledObjects; // Очередь для хранения неактивных объектов

    private void Awake()
    {
        InitializePool();
    }

    private void InitializePool()
    {
        pooledObjects = new Queue<GameObject>();

        for (int i = 0; i < poolSize; i++)
        {
            GameObject obj = Instantiate(objectPrefab);
            obj.SetActive(false);
            pooledObjects.Enqueue(obj);
        }
    }

    public GameObject GetPooledObject()
    {
        if (pooledObjects.Count > 0)
        {
            GameObject obj = pooledObjects.Dequeue();
            obj.SetActive(true);
            return obj;
        }
        else
        {
            // Если пул пуст, можно либо создать новый объект (не рекомендуется), либо расширить пул
            Debug.LogWarning("Object pool is empty!");
            return null;
        }
    }

    public void ReturnToPool(GameObject obj)
    {
        obj.SetActive(false);
        pooledObjects.Enqueue(obj);
    }
}

Подготовка к сборке проекта

Перед выпуском игры необходимо правильно настроить параметры сборки.

Добавление сцен в сборку:
- Перейдите в File -> Build Settings.
- Убедитесь, что все используемые сцены (меню, уровни, экран проигрыша) добавлены в список "Scenes in Build". Сцены без них не будут загружены в финальной версии игры.
Настройка целевой платформы:
- В окне Build Settings выберите целевую платформу (PC, Mac & Linux Standalone, Android, iOS и т.д.).
- Нажмите Switch Platform для применения настроек.
Параметры сборки:
- Выберите тип сборки: Development Build (для отладки) или обычную сборку.
- Укажите путь для сохранения собранного проекта.
- Нажмите Build для создания исполняемого файла и связанных с ним данных.

Заключение: отладка и финальная сборка

Перед выпуском игры в свет необходимо тщательно протестировать ее работу и выполнить корректную сборку. Этот этап критически важен для обеспечения стабильности и работоспособности финального продукта.

Комплексное тестирование:
- Проверьте все механики игры: перемещение, прыжок, бег, взаимодействие с объектами (Raycast), сбор предметов, поведение врагов.
- Убедитесь, что пользовательский интерфейс (UI) отображается корректно: Health Bar, Energy Bar, счетчик очков. Элементы не должны быть обрезаны при изменении разрешения экрана.
- Протестируйте логику сохранения прогресса через PlayerPrefs. Остановите игру после прохождения чекпоинта и убедитесь, что игрок возрождается в правильной точке при следующем запуске.
- Проверьте загрузку всех сцен: переход из меню в игру, экран проигрыша и возможность рестарта.
Оптимизация производительности:
- Если игра работает с низким FPS, проверьте использование ресурсоемких элементов.
- Уменьшите количество частиц в системах Particle System или ограничьте их область действия.
- Убедитесь, что для анимаций используется паттерн Object Pooling, особенно если они создаются часто.
- Слишком сложные модели или текстуры большого размера могут замедлять игру; рассмотрите возможность использования оптимизированных ассетов.
Процесс сборки проекта:
1. Перейдите в File -> Build Settings.
2. Убедитесь, что все необходимые сцены находятся в списке "Scenes in Build" и расположены в правильном порядке (например, первая — главное меню).
3. Выберите целевую платформу (например, PC, Mac & Linux Standalone).
4. Нажмите Build. Укажите папку для сохранения и задайте имя исполняемого файла (например, ApplePicker.exe).
5. Unity создаст исполняемый файл и папку с данными (например, ApplePicker_Data). Эти два компонента обязательно должны находиться в одной директории. Без папки с данными игра не запустится.
Финальная проверка:
- Выйдите из редактора Unity и запустите собранный .exe файл.
- Проверьте, что игра запускается, все механики работают, аудио и видео воспроизводятся корректно.
- Убедитесь, что управление и камера реагируют адекватно, UI отображается без артефактов.
- Если возникают проблемы, вернитесь в редактор, проверьте пути к ресурсам, настройки скриптов и повторите процесс сборки.

Введение​

Установка и настройка окружения​

Основные окна редактора Unity​

Игровые объекты и компоненты​

Префабы: повторное использование объектов​

Работа со скриптами​

Работа с UI (User Interface)​

Анимация и Timeline​

Физические взаимодействия: Rigidbody и Raycast​

Управление объектами: реализация механики "поднятия и переноски"​

Сцены и загрузка уровней​

Сохранение данных: PlayerPrefs​

Virtual Camera​

Работа с коллайдерами: триггеры и физические столкновения​

Управление видимостью объектов: SetActive()​

Оптимизация производительности: Object Pooling​

Подготовка к сборке проекта​

Заключение: отладка и финальная сборка​